package writtenTraining.day14;

import java.util.*;

/**
 * day14:（1）模拟+ 哈希：[编程题]乒乓球筐
 */
public class Main {
    public static void main(String[] args) {
        // 模拟 + 哈希

        // 输入
        Scanner in = new Scanner(System.in);
        // 多组输入
        while(in.hasNext()) {
            String src = in.next(), dest = in.next();
            int[] hash = new int[26];

            // 统计源字串
            for(int i = 0 ; i < src.length(); i++) {
                char ch = src.charAt(i);
                hash[ch - 'A']++;
            }

            // 查找
            int i =0;
            for(; i < dest.length(); i++) {
                char ch = dest.charAt(i);
                hash[ch - 'A']--;
                if(hash[ch - 'A'] < 0) {
                    
                    break;
                }
            }

            // 输出结果
            if(i < dest.length()) {
                System.out.println("No");
            } else {
                System.out.println("Yes");
            }
        }

    }
}

/**
 * day14:（2）贪心+排序：[编程题]组队竞赛
 */

 class Main1 {
    public static void main(String[] args) {
        // 贪心 + 排序

        // 输入数据
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] level = new int[n*3];
        int len = level.length;
        for(int i = 0; i < len ; i++) {
            level[i] = in.nextInt();
        }

        // 排序
        Arrays.sort(level);


        // 统计结果
        long ret = 0;
        int  pos = len - 2;
        while(n-- > 0) {
            // 从 len - 2开始遍历，间隔两个往前挑
            ret += level[pos];
            pos -= 2;
        }

        // 输出结果
        System.out.println(ret);
    }
}

/**
 * day14:(3)动态规划+哈希：DP25 删除相邻数字的最大分数
 */

class Main2 {
    public static void main(String[] args) {
        // 动态规划 + 哈希
        // 输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();

        int maxNum = 0;
        int[] hash = new int[10_001];
        for(int i = 0; i < n ; i++) {
            int num = in.nextInt();
            hash[num]++;
            maxNum = Math.max(num,maxNum);
        }
        // 创建dp
        int[] gp  = new int[maxNum+1];
        int[] dp = new int[maxNum+1];
        // dp[0] 表示不选, dp[1] 表示选
        for(int i = 1; i <= maxNum; i++) {

            // 当前位置选的情况
            dp[i] = gp[i - 1] + (i * hash[i]);
            // 当前位置不选的情况
            gp[i] = Math.max(gp[i - 1],dp[i - 1]);
        }



        // 输出
        System.out.println(Math.max(dp[maxNum],gp[maxNum]));
    }
}



 class Main4 {
    public static void main(String[] args) {
        // 拓扑排序 + bfs

        // 输入数据
        Scanner in = new Scanner(System.in);
        /**
         side 为边的有向边
         */
        Map<Integer,Integer> side = new HashMap<>();
        int n = in.nextInt() , m = in.nextInt();
        /**
         hash 表示入度的个数
         */
        Map<Integer,Integer> hash = new HashMap<>();
        List<Integer> list = new ArrayList<>();


        // 建图

        for(int i = 0; i < m; i++) {
            int outNum = in.nextInt();
            int intNum = in.nextInt();
            side.put(outNum,intNum);
            hash.put(intNum,hash.getOrDefault(intNum,0)+1);
            list.add(outNum);
        }

        Queue<Integer> queue = new LinkedList<>();
        // 统计入度为 0 的加入到队列中
        for(int num : list) {
            if(!hash.containsKey(num)) {
                queue.add(num);
            }
        }

        int[] ret = new int[n];
        // 进行 bfs
        while(!queue.isEmpty()) {
            int sz= queue.size();
            for(int i = 0; i < sz; i++) {
                // 出度
                int num = queue.poll();

                int non = side.get(num);
                hash.put(non,hash.get(non)-1);
                // 如果入度为 0 就加入
                if(hash.get(non) == 0) {
                    queue.add(non);
                }
            }
        }

        // 查找

    }
}


/**
 * day15:(3)拓扑排序+bfs:AB13 【模板】拓扑排序
 */

 class Main5 {
    public static void main(String[] args) {
        // 拓扑排序 + bfs

        // 输入数据
        Scanner in = new Scanner(System.in);
        /**
         side 为边的有向边
         */
        Map<Integer, List<Integer>> side = new HashMap<>();
        int n = in.nextInt(), m = in.nextInt();
        /**
         hash 表示入度的个数
         */
        int hash[] = new int[n+1];


        // 建图

        for (int i = 0; i < m; i++) {
            int outNum = in.nextInt();
            int intNum = in.nextInt();
            // 如果不存在就实例化一个邻接表
            if(!side.containsKey(outNum)) {
                side.put(outNum,new ArrayList<>());
            }

            // 加入有向边
            side.get(outNum).add(intNum);
            // 入度个数 + 1
            hash[intNum]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        // 统计入度为 0 的加入到队列中
        for (int i = 1; i <= n ; i++) {
            // 将入度为 0 的边加入队列
            if(hash[i] == 0) {
                queue.add(i);
            }
        }

        List<Integer> ret = new ArrayList<>();
        // 进行 bfs
        while (!queue.isEmpty()) {
            // 加入结果
            int num =  queue.poll();
            ret.add(num);
            // 遍历每一个入度
            for(int flg : side.getOrDefault(num, new ArrayList<>()))  {
                hash[flg]--;
                if(hash[flg] == 0) {
                    // 如果入度为 0 就入
                    queue.add(flg);
                }
            }
        }

        //特殊情况判断一下
        if (ret.size() < n) {
            System.out.println(-1);
        } else {
            int sz = ret.size();
            for (int i = 0; i < sz - 1; i++) {
                System.out.print(ret.get(i) + " ");
            }
            System.out.println(ret.get(sz-1));
        }

    }
}